package de.previsor.workflow.control;

import java.sql.*;
import java.util.ArrayList;
import de.previsor.workflow.model.TempData;
import de.previsor.workflow.control.helper.HashPw;
import java.security.NoSuchAlgorithmException;

/**
 *
 * @author Thomas Müller
 * 
 * V1.3 (15.12.2014)
 * 
 *
 */

public class DBConnect {    
    
    public Connection c = null;
    public Statement stmt;
    
    private ResultSet UserData;
    public String[] CachedUserData;
    
    public TempData CachedData;
    public HashPw hashpw;
    
    public DBConnect(){
        
        CachedData = new TempData();
    
    }

    
    /**************************************************************************************************************/
    
    
    /*
    * Öffnet eine Verbindung zur Datenbank
    */
    
    public void connect()
    {
        try
        {
            Class.forName("org.sqlite.JDBC");
            Connection c = DriverManager.getConnection("jdbc:sqlite:previsor.sqlite");
            stmt = c.createStatement();

        }
        catch(SQLException | ClassNotFoundException exe)
        {
            ErrorWindow(exe);
        }
    }
    
    /*
    * Schließt eine offene Verbindung zur Datenbank
    */
    
    public void disconnect()
    {
         try
        {
         stmt.close();
         c.close();
        }
        catch(Exception exe)
        {
            ErrorWindow(exe);
        }
    
    }
    
    /*
    * Überprüft, ob eine offene Verbindung zur Datenbank besteht
    */
    
    public boolean isconnected()
    {
        try
        {
            return !c.isClosed();
        }
        catch(Exception exe)
        {
            ErrorWindow(exe);
        }
        
        return false;
    }
    
    
    /**************************************************************************************************************/
    
    /**
    * Ausgabefenster für Fehlermeldungen
    * 
    * @param error Übergebene Fehlermeldung
    */
            
    public void ErrorWindow(Object error)
    {
        
    }
    
    /**************************************************************************************************************/
            
    /**
    * Holt sich die Daten eines Benutzers durch die übergebene Email Adresse und speichert diese in der Variable ChachedUserData
    *
     *@param id     ID des Benutzers, dessen Daten geholt werden sollen
    * @return       [0] = id, [1] = Vorname, [2] = Nachname, [3] = EMail, [4] = Bereich, [5] = Recht
    *
    */
    
    public String[] getUserData(int id)
    {
        connect();        
        CachedUserData = new String[6];
        int Arraypos = 0;
        
        try
        {
            UserData = stmt.executeQuery("SELECT * FROM mitarbeiter WHERE id = '" +id +"'");
            
            for(int i=0;i<=8;i++)
            {
                if(i==1) continue;
                CachedUserData[Arraypos] = UserData.getString(i+1);
                Arraypos++;          
            }
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }            
        
        disconnect();
        
        return CachedUserData;
    }
    
    /**
     * 
     * Überprüft ob das Passwort mit der EMail Adresse übereinstimmt.
     * 
     * @param email         EMail Adresse des Benutzers
     * @param passwort      Passwort des Benutzers
     * @return              'true' wenn das Passwort übereinstimmt | 'false' wenn das Passwort nicht übereinstimmt
     * @throws java.security.NoSuchAlgorithmException
     */
   
    public boolean authenticate(String email, String passwort) throws NoSuchAlgorithmException
    {
        connect();
        
        try
        {
            UserData = stmt.executeQuery("SELECT passwort FROM mitarbeiter WHERE email = '" +email +"'");
            hashpw = new HashPw(passwort);
            
            if(UserData.getString(1).equals(hashpw.hashing())) return true;

        }
        catch(SQLException | NoSuchAlgorithmException exe)
        {
            ErrorWindow(exe);
        }            
        
        disconnect();

        return false;
     
    }
    
    /**
     * 
     * Fügt der Datenbank einen neuen Benutzer hinzu
     * 
     * @param passwort Passwort des neuen Benutzers
     * @param vorname Vorname des neuen Benutzers
     * @param nachname Nachname des neuen Benutzers
     * @param email eMail des neuen Benutzers
     * @param bereich Arbeitsbereich des neuen Benutzers
     * @param recht Berechtigung des neuen Benutzers
     * @throws java.security.NoSuchAlgorithmException
     * @return true wenn User angelegt wurde, false wenn nicht
     */
    public boolean addUser(String passwort, String vorname, String nachname, String email, String bereich, String recht) throws NoSuchAlgorithmException
    {
        connect();
        
        try
        {
            ResultSet NewUser = stmt.executeQuery("SELECT COUNT(id) AS usercount FROM mitarbeiter WHERE email = '" +email +"'");
            NewUser.next();
            int count = NewUser.getInt("usercount");
            
            if(count == 0)
            {    
                ResultSet getID = stmt.executeQuery("SELECT id FROM mitarbeiter ORDER BY ID DESC LIMIT 1");                 
                getID.next();
                int id = getID.getInt(1) +1;
                hashpw = new HashPw(passwort);
                stmt.executeUpdate("INSERT INTO mitarbeiter (id,passwort,vorname,nachname,email,bereich,recht) VALUES ('"+id+"','"+hashpw.hashing()+"','"+vorname+"','"+nachname+"','"+email+"','"+bereich+"','"+recht+"')");
                return true;
            }
            else
            {
                System.out.println("User allready exists");
            }
        }
        catch(SQLException | NoSuchAlgorithmException exe)
        {
            ErrorWindow(exe);
        }     
        
        disconnect();
        return false;

    }
    
    /**
     * 
     * Überschreibt die Daten eines Benutzers mit den übergebenen Werten
     * 
     * @param id            ID des Benutzers
     * @param vorname       Vorname des neuen Benutzers
     * @param nachname      Nachname des neuen Benutzers
     * @param email         eMail des neuen Benutzers
     * @param bereich       Arbeitsbereich des neuen Benutzers
     * @param recht         Berechtigung des neuen Benutzers
     * @return              true, wenn der Benutzer der Datenbank hinzugefügt wurde | false wenn nicht
     */
    
    public boolean updateUser(int id, String vorname, String nachname, String email, String bereich, String recht)
    {
        connect();
        
        try
        {
            stmt.executeUpdate("UPDATE mitarbeiter SET vorname = '"+vorname+"', nachname = '"+nachname+"', email = '"+email+"', bereich = '"+bereich+"', recht = '"+recht+"' WHERE id = '"+id+"'"); 
            return true;
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }    
        
        disconnect();
        return false;

    }
    
    /**
     * 
     * Löscht einen Benutzer aus der Datenbank
     * 
     * @param email     EMail des Benutzers, welcher gelöscht werden soll
     * @return          true, wenn der Benutzer gelöscht wurde | false wenn nicht
     */
    
    public boolean deleteUser(String email)
    {
        connect();
        
        try
        {
            stmt.executeUpdate("DELETE FROM mitarbeiter WHERE email = '"+email+"'"); 
            return true;
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        return false;

    }
    
    /**
     * 
     * Gibt alle Kollegen eines Benutzers zurück
     * 
     * @param id            id des Benuters dessen Kollegen bestimmt werden sollen (kann mit getUserID(email) abgefragt werden)
     * @return collagues    [0] ID [1] Vorname [2] Nachname [3] EMail [4] Bereich [5] Berechtigung
     */
    
    public ArrayList<String[]> getColleagues(int id)
    {
        ArrayList<String[]> colleagues = new ArrayList<>();
        String[] temp;
        int Arraypos;
        
        connect();
        
        try
        {
            ResultSet col = stmt.executeQuery("SELECT * FROM mitarbeiter WHERE id != '" +id +"'");            

            while(col.next())
            {
                temp = new String[6];
                Arraypos = 0;
                
                for(int i=0;i<7;i++)
                {
                    if(i==1) continue;
                    temp[Arraypos] = col.getString(i+1);
                    Arraypos++;
                }
                
                colleagues.add(temp);
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }
        
        disconnect();
        return colleagues;

    }
    
    
    /**
     * 
     * Gibt die ID des zur EMail Adresse zugehörigen Benutzers zurück
     * 
     * @param email     EMail Adresse des Benutzers, dessen ID ausgegeben werden soll
     * @return          ID des Benutzers
     */
    
    public int getUserID(String email)
    {
        int UserID = 0;
        
        connect();
        
        try
        {
           UserID =  stmt.executeQuery("SELECT id FROM mitarbeiter WHERE email = '"+email+"'").getInt(1);
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        
        return UserID;
    
    }
    

    /**************************************************************************************************************/
    
    /**
    * Legt einen neuen Auftrag an
    * 
    * @param title          Titel des Auftrags
    * @param company        Name des Unternehmens
    * @param street         Adresse des Unternehmens
    * @param number         Hausnummer
    * @param zip            Postleitzahl
    * @param town           Stadt
    * @param duedate        Frist         
    * @param assignedto     Zugewisener Mitarbeiter oder Bereich
    * @param status         Status (0 = erledigt, 1 = offen)
    * @param description    Beschreibung des Auftrags
    * @param notes          Notizen zum Auftrag
    * @param picpath        Bildpfad
    * @return               true wenn Auftrag angelegt wurde | false wenn nicht
    */
    
    public boolean addTask(String title, String company, String street, int number, int zip, String town, String duedate, String assignedto, int status, String description, String notes, String picpath )
    {
        connect();
                
        try
        {
            ResultSet NewTask = stmt.executeQuery("SELECT COUNT(id) AS taskcount FROM auftraege WHERE titel = '" +title +"'");
            NewTask.next();
            
            if(NewTask.getInt("taskcount") == 0)
            {
                ResultSet getID = stmt.executeQuery("SELECT id FROM auftraege ORDER BY ID DESC LIMIT 1");                 
                getID.next();
                int newID = getID.getInt(1) +1;
                stmt.executeUpdate("INSERT INTO auftraege (id,titel,unternehmen,strasse,nr,plz,stadt,frist,zuweisung,status,beschreibung,notiz,bildpfad) VALUES ("+newID +",'"+title+"','"+company+"','"+street+"','"+number+"','"+zip+"','"+town+"','"+duedate+"','"+assignedto+"','"+status+"','"+description+"','"+notes+"','"+picpath+"')");
                return true;
            }
            else
            {
                disconnect();
                updateTask(getTaskID(title), title, company, street, number, zip, town, duedate, assignedto, status, description, notes, picpath);
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }   
        
        disconnect();
        return false;
    }
    
    /**
    * 
    * Überschreibt einen bestehenden Auftrag mit den übergebenen Daten
    * 
    * @param id             ID des Auftrags
    * @param title          Titel des Auftrags
    * @param company        Name des Unternehmens
    * @param street         Adresse des Unternehmens
    * @param number         Hausnummer
    * @param zip            Postleitzahl
    * @param town           Stadt
    * @param duedate        Frist         
    * @param assignedto     Zugewisener Mitarbeiter oder Bereich
    * @param status         Status (0 = erledigt, 1 = offen)
    * @param description    Beschreibung des Auftrags
    * @param notes          Notizen zum Auftrag
    * @param picpath        Bildpfad
    * @return               true, wenn der Auftrag aktualisiert wurde | false wenn nicht
    */
    
    public boolean updateTask(int id,String title, String company, String street, int number, int zip, String town, String duedate, String assignedto, int status, String description, String notes, String picpath)
    {
        
        connect();
        
        try
        {
            stmt.executeUpdate("UPDATE auftraege SET titel = '"+title +"', unternehmen = '"+company +"', strasse = '"+street +"', nr = '"+number +"', plz = '"+zip +"', stadt = '"+town +"', frist = '"+duedate +"', zuweisung = '"+assignedto +"', status = '"+status +"',beschreibung = '"+description +"',notiz = '"+notes +"',bildpfad = '"+picpath +"' WHERE id = '" +id +"'");
            return true;
        }
        catch(Exception exe)
        {
            ErrorWindow(exe);
            exe.printStackTrace();
        }
    
        disconnect();
        return false;
    }
    
    /**
     * 
     * Löscht den Auftrag mit der übergebenen ID aus der Datenbank
     * 
     * @param taskID    ID des Auftrags
     * @return          true, wenn der Auftrag gelöscht wurde | false wenn nicht
     */
 
    public boolean deleteTask(int taskID)
    {
        connect();
        
        try
        {
            stmt.executeUpdate("DELETE FROM auftraege WHERE id = '"+taskID+"'"); 
            return true;
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        return false;
   
    }
    
    /**
     * 
     * Gibt die TaskID des Auftrags mit dem übergebenen Titel aus
     * 
     * @param   title       Titel des Auftrags dessen ID bestimmt werden soll
     * @return  taskID      TaskID des übergebenen Auftrags
     */
    
    public int getTaskID(String title)
    {
        int taskID = 0;
        
        connect();
        
        try
        {
           taskID =  stmt.executeQuery("SELECT id FROM auftraege WHERE titel = '"+title+"'").getInt(1);
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        
        return taskID;
    
    }
    
    /**
     * 
     * Gibt alle Tasks in der Datenbank aus 
     * 
     * @return Alle Aufträge in der Datenbank als ArrayList
     */
    
    public ArrayList<String[]> getTasks()
    {
        System.out.println("Start");
        ArrayList<String[]> tasks = new ArrayList<>();
        String[] temp;
        int Arraypos;
        
        connect();
        
        try
        {
            System.out.println("Start");
            ResultSet taskvar = stmt.executeQuery("SELECT * FROM auftraege");            

            while(taskvar.next())
            {
                temp = new String[13];
                Arraypos = 0;
                
                for(int i=0;i<13;i++)
                {
                    temp[Arraypos] = taskvar.getString(i+1);
                    Arraypos++;
                }
                
                tasks.add(temp);
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }
        
        disconnect();
        return tasks;

    }
    
    /**
     * 
     * Gibt alle Tasks in der Datenbank aus, welche den übergebenen Status besitzen und dem übergebenen Benutzer / Bereich zugewiesen wurden
     * 
     * @param assignedTo    Zugewisener Mitarbeiter oder Bereich
     * @param status        Status (true = all, false = alle offenen)
     * @return 
     */
    
    public ArrayList<String[]> getTasks(String assignedTo, boolean status)
    {
        ArrayList<String[]> tasks = new ArrayList<>();
        String[] temp;
        int Arraypos;
        
        connect();        
        
        try
        {
            if(status)
            {
            
            ResultSet taskvar = stmt.executeQuery("SELECT * FROM auftraege where zuweisung = '"+assignedTo+"'");     

                while(taskvar.next())
                {
                    temp = new String[10];
                    Arraypos = 0;
                
                    for(int i=0;i<10;i++)
                    {
                        temp[Arraypos] = taskvar.getString(i+1);
                        Arraypos++;
                    }
                
                    tasks.add(temp);
                }
            }
            else
            {
                
            ResultSet taskvar = stmt.executeQuery("SELECT * FROM auftraege where zuweisung = '"+assignedTo+"' AND status = '1'");     

                while(taskvar.next())
                {
                    temp = new String[10];
                    Arraypos = 0;
                
                    for(int i=0;i<10;i++)
                    {
                        temp[Arraypos] = taskvar.getString(i+1);
                        Arraypos++;
                    }
                
                    tasks.add(temp);
                }
                    
                    
            }
            
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }
        
        disconnect();
        return tasks;

    }
    /**************************************************************************************************************/
    
    /**
     * 
     * Legt ein neues Unternehmen mit den übergebenen Werten in der Datenbank an
     * 
     * @param name          Name des Unternehmens
     * @param street        Anschrift 
     * @param number        Hausnummer
     * @param zip           Postleitzahl
     * @param contact       Ansprechpartner
     * @param phone         Telefonnummer
     * @param email         EMail Adresse
     * @return true wenn Unternehmen angelegt wurde, false wenn nicht
     */
    
    public boolean addCompany(String name, String street, int number, int zip, String contact, String phone, String email)
    {
        connect();
                
        try
        {
            ResultSet NewCompany = stmt.executeQuery("SELECT COUNT(id) AS companycount FROM unternehmen WHERE bezeichnung = '" +name +"'");
            NewCompany.next();
            
            
            if(NewCompany.getInt("companycount") == 0)
            {
                ResultSet getID = stmt.executeQuery("SELECT id FROM unternehmen ORDER BY ID DESC LIMIT 1");                 
                getID.next();
                int newID = getID.getInt(1) +1;
                stmt.executeUpdate("INSERT INTO unternehmen (id,bezeichnung,strasse,nr,plz,ansprechpartner,tel,email) VALUES ("+newID +",'"+name +"','"+street +"','"+number +"','"+zip +"','"+contact +"','"+phone +"','"+email +"')");        
                return true;
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }   
        
        disconnect();
        return false;
    
    }
    
    /**
     * 
     * Überschreibt die hinterlegten Informationen eines Unternehmens in der Datenbank mit den übergebenen Werten
     * 
     * @param id        ID des Unternehmens
     * @param name      Name
     * @param street    Anschrift 
     * @param number    Hausnummer
     * @param zip       Postleitzahl
     * @param contact   Ansprechpartner
     * @param phone     Telefonnummer
     * @param email     EMail Adresse
     * @return          true, wenn die Daten des Unternehmens aktualsiiert wurden | false wenn nicht 
     */
    
    public boolean updateCompany(int id,String name, String street, int number, int zip, String contact, String phone, String email)
    {
        
        connect();
        
        try
        {
            stmt.executeUpdate("UPDATE unternehmen SET bezeichnung = '"+name +"', strasse = '"+street +"', nr = '"+number +"', plz = '"+zip +"', ansprechpartner = '"+contact +"', tel = '"+phone +"', email = '"+email +"' WHERE id = '" +id +"'");
            return true;
        }
        catch(Exception exe)
        {
            ErrorWindow(exe);
        }
    
        disconnect();
        return false;
    }
    
    /**
     * 
     * Löscht das Unternehmen mit der übergebenen ID aus der Datenbank
     * 
     * @param companyID     ID des Unternehmens, welches aus der Datenbank gelöscht werden soll
     * @return              true, wenn das Unternehmen aus der Datenbank gelöscht wurde | false wenn nicht
     */
    
    public boolean deleteCompany(int companyID)
    {
        connect();
        
        try
        {
            stmt.executeUpdate("DELETE FROM unternehmen WHERE id = '"+companyID+"'"); 
            return true;
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        return false;
   
    }
    
    /**
     * 
     * Gibt die CompanyID des Unternehmens mit dem übergebenen Namen aus
     * 
     * @param name          Name des Unternehmens dessen ID bestimmt werden soll
     * @return CompanyID    ID des übergebenen Unternehmens
     */
    
    public int getCompanyID(String name)
    {
        int CompanyID = 0;
        
        connect();
        
        try
        {
           CompanyID =  stmt.executeQuery("SELECT id FROM unternehmen WHERE bezeichnung = '"+name+"'").getInt(1);
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        
        return CompanyID;
    
    }
    
    /**************************************************************************************************************/
    
    /**
     * 
     * Legt ein neues Asset in der Datenbank an
     * 
     * @param title         Bezeichnung des Assets
     * @param path          Pfad zum Asset
     * @param category      Kategorie
     * @param type          Typ
     * @param author        Author
     * @return              true wenn Asset hinzugefügt wurde | false wenn nicht
     */
    
    public boolean addAsset(String title, String path, int category, int type, int author)
    {
        connect();
        try
        {
            ResultSet NewAsset = stmt.executeQuery("SELECT COUNT(id) AS assetcount FROM assets WHERE titel = '" +title +"'");
            NewAsset.next();
            
            if(NewAsset.getInt("assetcount") == 0)
            {
                ResultSet getID = stmt.executeQuery("SELECT id FROM assets ORDER BY ID DESC LIMIT 1");                 
                getID.next();
                int newID = getID.getInt(1) +1; 
                stmt.executeUpdate("INSERT INTO assets (id,titel,pfad,kategorie,typ,author) VALUES ("+newID +",'"+title+"','"+path+"','"+category+"','"+type+"','"+author+"')");        
                return true;
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }   
        
        disconnect();
        return false;
    
    }
    
    /**
     * 
     * Überschreibt die Eigenschaften eines Assets mit den übergebenen Werten
     * 
     * @param id            ID des Assets
     * @param title         Bezeichnung des Assets
     * @param path          Pfad zum Asset
     * @param category      Kategorie
     * @param type          Typ
     * @param author        Author
     * @return              true, wenn das Asset aktualisiert wurde | false wenn nicht
     */
    
    public boolean updateAsset(int id,String title, String path, int category, int type, int author)
    {
        
        connect();
        
        try
        {
            stmt.executeUpdate("UPDATE assets SET titel = '"+title +"', pfad = '"+path +"', kategorie = '"+category +"', typ = '"+type +"', author = '"+author +"' WHERE id = '" +id +"'");
            return true;
        }
        catch(Exception exe)
        {
            ErrorWindow(exe);
        }
    
        disconnect();
        return false;
    }
    
    /**
     * 
     * Löscht das Asset mit der übergebenen ID aus der Datenbank
     * 
     * @param assetID       ID des zu löschenden Assets
     * @return              true, wenn das Asset aus der Datenbank gelöscht wurde | false wenn nicht
     */
    
    public boolean deleteAsset(int assetID)
    {
        connect();
        
        try
        {
            stmt.executeUpdate("DELETE FROM assets WHERE id = '"+assetID+"'"); 
            return true;
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        return false;
   
    }
    
    /**
     * 
     * Gibt die ID des Assets mit dem übergebenen Titel aus
     * 
     * @param title         Titel des Assets dessen ID bestimmt werden soll
     * @return AssetID      ID des übergebenen Assets - Es wird 0 zurückgegeben wenn kein Asset mit dem übergebenen Titel existiert !
     */
    
    public int getAssetID(String title)
    {
        int AssetID = 0;
        
        connect();
        
        try
        {
           AssetID =  stmt.executeQuery("SELECT id FROM assets WHERE titel = '"+title+"'").getInt(1);
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        
        return AssetID;
    
    }

     /**************************************************************************************************************/
    
    /**
     * 
     * Leget einen neuen Asset Typ mit der übergebenen Bezeichnung an
     * 
     * @param type  Bezeichnung des neuen Typs 
     * @return      true, wenn der Asset Typ in der Datenbank hinterlegt wurde | false wenn nicht 
     */
    
    public boolean addAssetType(String type)
    {
        connect();
                
        try
        {
            ResultSet NewAssetType = stmt.executeQuery("SELECT COUNT(id) AS assettpyecount FROM typ_assets WHERE typ = '" +type +"'");
            NewAssetType.next();
            
            
            if(NewAssetType.getInt("assettpyecount") == 0)
            {
                ResultSet getID = stmt.executeQuery("SELECT id FROM typ_assets ORDER BY ID DESC LIMIT 1");                 
                getID.next();
                int newID = getID.getInt(1) +1;
                stmt.executeUpdate("INSERT INTO typ_assets (id,typ) VALUES ("+newID +",'"+type +"')");
                return true;
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }   
        
        disconnect();
        return false;
    
    }
    
    /**
     * 
     * Überschreibt einen Asset Typ mit den übergebenen Werten
     * 
     * @param id        ID des Asset Typs, dessen Eigenschaften überschrieben werden sollen
     * @param type      Neue Bezeichnung des Typs
     * @return          truem wenn der Asset Typ aktualisiert wurde | false wenn nicht
     */
    
    public boolean updateAssetType(int id,String type)
    {
        
        connect();
        
        try
        {
            stmt.executeUpdate("UPDATE typ_assets SET typ = '"+type +"' WHERE id = '"+id +"'");
            return true;
        }
        catch(Exception exe)
        {
            ErrorWindow(exe);
        }
    
        disconnect();
        return false;
    }
    
    /**
     * 
     * Löscht den Asset Typ mit der übergebenen ID aus der Datenbank
     * 
     * @param assetTypeID   Id des Asset Typs, der gelöscht werden soll
     * @return              truem wenn der Asset Typ gelöscht wurde | false wenn nicht
     */
    
    public boolean deleteAssetType(int assetTypeID)
    {
        connect();
        
        try
        {
            stmt.executeUpdate("DELETE FROM typ_assets WHERE id = '"+assetTypeID+"'"); 
            return true;
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        return false;
   
    }
    
    /**
     * 
     * Gibt die ID des übergebenen Asset Typs aus
     * 
     * @param type              Typ, dessen ID bestimmt werden soll
     * @return AssetTypeID      ID des übergebenen Asset Typs
     */
    
    public int getAssetTypeID(String type)
    {
        int AssetTypeID = 0;
        
        connect();
        
        try
        {
           AssetTypeID =  stmt.executeQuery("SELECT id FROM typ_assets WHERE typ = '"+type+"'").getInt(1);
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        
        return AssetTypeID;
    
    }
    
    /**
     * 
     * Gibt alle Asset Typen aus der Datenbak zurück
     * 
     * @return 
     */
    
    public ArrayList<String[]> getAssetTypes()
    {
        ArrayList<String[]> assettypes = new ArrayList<>();
        String[] temp;
        int Arraypos;
        
        connect();
        
        try
        {
            ResultSet col = stmt.executeQuery("SELECT * FROM typ_assets");            

            while(col.next())
            {
                temp = new String[2];
                Arraypos = 0;
                
                for(int i=0;i<2;i++)
                {
                    temp[Arraypos] = col.getString(i+1);
                    Arraypos++;
                }
                
                assettypes.add(temp);
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }
        
        disconnect();
        return assettypes;

    }
    
    
    
    
     /**************************************************************************************************************/
    
    /**
     * 
     * Leget eine neue Unterkategorie mit der übergebenen Bezeichnung an
     * 
     * @param name      Bezeichnung der neuen Unterkategorie
     * @param maincat   Zugehörige Oberkategorie
     * @return          true wenn die Unter-Kategorie der Datenbank hinzugefügt wurde | false wenn nicht
     */
    
    public boolean addSubCategory(String name, String maincat)
    {
        connect();
                
        try
        {
            ResultSet NewCategory = stmt.executeQuery("SELECT COUNT(id) AS catcount FROM unter_kategorie WHERE name = '" +name +"'");
            NewCategory.next();
            
            
            if(NewCategory.getInt("catcount") == 0)
            {
                ResultSet getID = stmt.executeQuery("SELECT id FROM unter_kategorie ORDER BY ID DESC LIMIT 1");                 
                getID.next();
                int newID = getID.getInt(1) +1;
                stmt.executeUpdate("INSERT INTO unter_kategorie (id,name,oberkategorie) VALUES ("+newID +",'"+name +"','"+maincat +"')");
                return true;
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }   
        
        disconnect();
        return false;
    
    }
    
    /**
     * 
     * Überschreibt eine bestehende Unterkategorie mit den übergebenen Werten
     * 
     * @param id        ID der Unterkategorie (kann mit getSubCategoryID() geholt werden)
     * @param name      Name der Unterkategorie
     * @param maincat   Name der Oberkategorie
     * @return 
     */
    
    public boolean updateSubCategory(int id,String name,String maincat)
    {
        
        connect();
        
        try
        {
            stmt.executeUpdate("UPDATE unter_kategorie SET name = '"+name +"', oberkategorie = '"+maincat+"' WHERE id = '"+id +"'");
            return true;
        }
        catch(Exception exe)
        {
            ErrorWindow(exe);
        }
    
        disconnect();
        return false;
    }
    
    
    /**
     * 
     * Löscht die Unter-Kategorie mit der übergebenen ID aus der Datenbank
     * 
     * @param SubCategoryID   Id des Asset Typs, der gelöscht werden soll
     * @return true wenn die Unter-Kategorie aus der Datenbank gelöscht wurde | false wenn nicht
     */
    
    public boolean deleteSubCategory(int SubCategoryID)
    {
        connect();
        
        try
        {
            stmt.executeUpdate("DELETE FROM unter_kategorie WHERE id = '"+SubCategoryID+"'"); 
            return true;
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        return false;
   
    }
    
    /**
     * 
     * Gibt die ID der übergebenen Unter-Kategorie aus
     * 
     * @param name              Unter-Kategorie, dessen ID bestimmt werden soll
     * @return AssetTypeID      ID der Unter-Kategorie
     */
    
    public int getSubCategoryID(String name)
    {
        int SubCategoryID = 0;
        
        connect();
        
        try
        {
           SubCategoryID =  stmt.executeQuery("SELECT id FROM unter_kategorie WHERE name = '"+name+"'").getInt(1);
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        
        return SubCategoryID;
    
    }
    
    /**
     * 
     * Gibt alle Unter-Kategorien aus der Datenbak zurück
     * 
     * @return  alle Unter-Kategorien in der Datenbank
     */
    
    public ArrayList<String> getSubCategorys()
    {
        ArrayList<String> assettypes = new ArrayList<>();
        String temp;

        
        connect();
        
        try
        {
            ResultSet col = stmt.executeQuery("SELECT * FROM unter_kategorie");            

            while(col.next())
            {
                temp = col.getString(2);
                
                assettypes.add(temp);
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }
        
        disconnect();
        return assettypes;

    }
    
    /**************************************************************************************************************/
    
    
    /**
     * 
     * Legt eine neue Asset Kategorie samt Unterkategorie mit der übergebenen Bezeichnung an
     * 
     * @param category      Bezeichnung der neuen Kategorie 
     * @param subcategory   ID der Unter-Kategorie
     * @return              true, wenn die Asset Kategorie der Datenbank hinzugefügt wurde | false wenn nicht
     */
    
    public boolean addAssetCategory(String category, int subcategory)
    {
        connect();
        try
        {
            
            ResultSet NewAssetCategory = stmt.executeQuery("SELECT COUNT(id) AS assetcategorycount FROM kat_assets WHERE kat = '" +category +"'");
            NewAssetCategory.next();
            
            
            if(NewAssetCategory.getInt("assetcategorycount") == 0)
            {
                ResultSet getID = stmt.executeQuery("SELECT id FROM kat_assets ORDER BY ID DESC LIMIT 1");                 
                getID.next();
                int newID = getID.getInt(1) +1;
                stmt.executeUpdate("INSERT INTO kat_assets (id,kat,unterkat) VALUES ("+newID +",'"+category +"','"+subcategory +"')");  
                return true;
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
            exe.printStackTrace();
        }   
        
        disconnect();
        return false;
    
    }
    
    /**
     * 
     * Legt eine neue Asset Kategorie mit der übergebenen Bezeichnung an
     * 
     * @param category      Bezeichnung der neuen Kategorie 
     * @return              true, wenn die Asset Kategorie der Datenbank hinzugefügt wurde | false wenn nicht
     */
    
    public boolean addAssetCategory(String category)
    {
        connect();
        try
        {
            
            ResultSet NewAssetCategory = stmt.executeQuery("SELECT COUNT(id) AS assetcategorycount FROM kat_assets WHERE kat = '" +category +"'");
            NewAssetCategory.next();
            
            
            if(NewAssetCategory.getInt("assetcategorycount") == 0)
            {
                ResultSet getID = stmt.executeQuery("SELECT id FROM kat_assets ORDER BY ID DESC LIMIT 1");                 
                getID.next();
                int newID = getID.getInt(1) +1;
                stmt.executeUpdate("INSERT INTO kat_assets (id,kat,unterkat) VALUES ("+newID +",'"+category +"','0')");  
                return true;
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
            exe.printStackTrace();
        }   
        
        disconnect();
        return false;
    
    }
    
    /**
     * 
     * Überschreibt eine Asset Kategorie mit den übergebenen Werten
     * 
     * @param id            ID der Asset Kategorie, dessen Eigenschaften überschrieben werden sollen
     * @param category      Neue Bezeichnung der Kategorie
     * @param subcategory   ID der Unter-Kategorie
     * @return              true, wenn die Asset Kategorie aktualisiert wurde | false wenn nicht
     */
    
    public boolean updateAssetCategory(int id,String category,int subcategory)
    {
        
        connect();
        
        try
        {
            stmt.executeUpdate("UPDATE kat_assets SET kat = '"+category +"', unterkat = '"+subcategory+"' WHERE id = '"+id +"'");
            return true;
        }
        catch(Exception exe)
        {
            ErrorWindow(exe);
        }
    
        disconnect();
        return false;
    }
    
    /**
     * 
     * Überschreibt eine Asset Kategorie mit den übergebenen Werten
     * 
     * @param id            ID der Asset Kategorie, dessen Eigenschaften überschrieben werden sollen
     * @param category      Neue Bezeichnung der Kategorie
     * @return              true, wenn die Asset Kategorie aktualisiert wurde | false wenn nicht
     */
    
    public boolean updateAssetCategory(int id,String category)
    {
        
        connect();
        
        try
        {
            stmt.executeUpdate("UPDATE kat_assets SET kat = '"+category +"' WHERE id = '"+id +"'");
            return true;
        }
        catch(Exception exe)
        {
            ErrorWindow(exe);
        }
    
        disconnect();
        return false;
    }
    
    /**
     * 
     * Löscht die Kategorie mit der übergebenen ID aus der Datenbank
     * 
     * @param assetCategoryID   Id der Asset Kategorie, die gelöscht werden soll
     * @return                  true, wenn die Asset Kategorie aus der Datenbank gelöscht wurde | false wenn nicht
     */
    
    public boolean deleteAssetCategory(int assetCategoryID)
    {
        connect();
        
        try
        {
            stmt.executeUpdate("DELETE FROM kat_assets WHERE id = '"+assetCategoryID+"'"); 
            return true;
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        return false;
   
    }
    
    /**
     * 
     * Gibt die ID der übergebenen Asset Kategorie aus
     * 
     * @param category          Kategroei, dessen ID bestimmt werden soll
     * @return AssetCategoryID  ID der übergebenen Asset Kategorie
     */
    
    public int getAssetCategoryID(String category)
    {
        int AssetCategoryID = 0;
        
        connect();
        
        try
        {
           AssetCategoryID =  stmt.executeQuery("SELECT id FROM kat_assets WHERE kat = '"+category+"'").getInt(1);
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        
        return AssetCategoryID;
    
    }
    
    /**
     * 
     * Gibt alle Asset Kategorien aus der Datenbank zurück
     * 
     * @return 
     */
    
    public ArrayList<String[]> getCategorys()
    {
        ArrayList<String[]> categorys = new ArrayList<>();
        String[] temp;
        int Arraypos;
        
        connect();
        
        try
        {
            ResultSet col = stmt.executeQuery("SELECT * FROM kat_assets");            

            while(col.next())
            {
                temp = new String[3];
                Arraypos = 0;
                
                for(int i=0;i<3;i++)
                {
                    temp[Arraypos] = col.getString(i+1);
                    Arraypos++;
                }
                
                categorys.add(temp);
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }
        
        disconnect();
        return categorys;

    }
    
    
    /**************************************************************************************************************/
    
    
    /**
     * 
     * Speichert die Beziehung eines Moebelstuecks zu einem Auftrag in der Datenbank
     * 
     * @param object    Moebelstueck
     * @param task      Auftrag
     * @return          true, wenn die Beziehung der Datenbank hinzugefügt wurde | false wenn nicht
     */
    
    public boolean addRelationship(int object,int task)
    {
        connect();
        
        try
        {
            ResultSet NewRelationship = stmt.executeQuery("SELECT COUNT(id) AS relcount FROM auftr_moebel WHERE objekt = '" +object +"' AND auftrag = '"+task+"'");
            NewRelationship.next();
            
            
            if(NewRelationship.getInt("relcount") == 0)
            {
                ResultSet getID = stmt.executeQuery("SELECT id FROM auftr_moebel ORDER BY ID DESC LIMIT 1");                 
                getID.next();
                int newID = getID.getInt(1) +1;
                stmt.executeUpdate("INSERT INTO auftr_moebel (id,objekt,auftrag) VALUES ('"+newID +"','"+object +"','"+task+"')");  
                return true;
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }           
        disconnect();
        return false;
    
    }
    
    /**
     * 
     * Überschreibt die Daten einer Beziehung mit den übergebenen Werten
     * 
     * @param id        ID der Beziehung, welche geändert werden soll
     * @param object    Neues Object
     * @param task      Neuer Auftrag
     * @return          true, wenn die Beziehung aktualisiert wurde | false wenn nicht
     */
    
    public boolean updateRelationship(int id, int object, int task)
    {
        
        connect();
        
        try
        {
            stmt.executeUpdate("UPDATE auftr_moebel SET objekt = '"+object +"' , auftrag = '" +task +"' WHERE id = '"+id +"'");
            return true;
        }
        catch(Exception exe)
        {
            ErrorWindow(exe);
        }
    
        disconnect();
        return false;
    }
    
    /**
     * 
     * Löscht eine Beziehung aus der Datenbank
     * 
     * @param RelationshipID    ID der Beziehung, welche gelöscht werden soll
     * @return                  true, wenn die Beziehung aus der Datenbank gelöscht wurde | false wenn nicht
     */
    
    public boolean deleteRelationship(int RelationshipID)
    {
        connect();
        
        try
        {
            stmt.executeUpdate("DELETE FROM auftr_moebel WHERE id = '"+RelationshipID+"'"); 
            return true;
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        return false;
   
    }
    
    /**
     * 
     * Gibt die ID der übergebenen Beziehung zwischen einem Objekt und einem Auftrag zurück
     * 
     * @param object    Objekt
     * @param task      Auftrag
     * @return          ID der Beziehung
     */
    
    public int getRelationshipID(int object, int task)
    {
        int RelationshipID = 0;
        
        connect();
        
        try
        {
           RelationshipID =  stmt.executeQuery("SELECT id FROM auftr_moebel WHERE objekt = '"+object+"' AND auftrag = '" +task + "'").getInt(1);
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        
        return RelationshipID;
    
    }
    
    /**************************************************************************************************************/
    
    /**
     * 
     * Legt eine neue Berechtigung in der Datenbank an
     * 
     * @param perm      Bezeichnung der Berechtigung (z.B. 3D-Modeller)
     * @return          true, wenn die Berechtigung der Datenbank hinzugefügt wurde | false wenn nicht
     */
    
    public boolean addPermission(String perm)
    {
        connect();
        
        try
        {
            ResultSet NewPermission = stmt.executeQuery("SELECT COUNT(id) AS permcount FROM rechte WHERE recht = '" +perm +"'");
            NewPermission.next();
            
            
            if(NewPermission.getInt("permcount") == 0)
            {
                ResultSet getID = stmt.executeQuery("SELECT id FROM rechte ORDER BY ID DESC LIMIT 1");                 
                getID.next();
                int newID = getID.getInt(1) +1;
                stmt.executeUpdate("INSERT INTO rechte (id,recht) VALUES ("+newID +",'"+perm+"')");
                return true;
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }   
        
        disconnect();
        return false;
    }
    
    /**
     * 
     * Überschreibt eine Berechtigung mit dem übergebenen Wert in der Datenbank
     * 
     * @param id        ID der zu überschreibenden Berechtigung
     * @param perm      Neuer Name der Berechtigung
     * @return          true, wenn die Berechtigung aktualisiert wurde | false wenn nicht
     */
    
    public boolean updatePermission(int id, String perm)
    {
        
        connect();
        
        try
        {
            stmt.executeUpdate("UPDATE rechte SET recht = '"+perm +"' WHERE id = '"+id +"'");
            return true;
        }
        catch(Exception exe)
        {
            ErrorWindow(exe);
        }
    
        disconnect();
        return false;
    }
    
    /**
     * 
     * Löscht eine Berechtigung aus der Datenbank
     * 
     * @param PermissionID      ID der Berechtigung, welche gelöscht werden soll
     * @return                  true, wenn die Berechtigung aus der Datenbank gelöscht wurde | false wenn nicht
     */
    
    public boolean deletePermission(int PermissionID)
    {
        connect();
        
        try
        {
            stmt.executeUpdate("DELETE FROM rechte WHERE id = '"+PermissionID+"'"); 
            return true;
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        return false;
   
    }
    
    /**
     * 
     * Gibt die ID einer Berechtigung aus der Datenbank aus
     * 
     * @param perm      Name der Berechtigung dessen ID ausgegeben werden soll
     * @return          ID der Berechtigung          
     */
    
    public int getPermissionID(String perm)
    {
        int PermissionID = 0;
        
        connect();
        
        try
        {
           PermissionID =  stmt.executeQuery("SELECT id FROM rechte WHERE recht = '"+perm+"'").getInt(1);
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        
        return PermissionID;
    
    }

    /**************************************************************************************************************/
    
    /**
     * 
     * Legt einen neuen Bereich in der Datenbank an
     * 
     * @param section   Name des Bereichs
     * @return          true, wenn der Bereich hinzugefügt wurde | false wenn nicht
     */
    
    public boolean addSection(String section)
    {
        connect();
        
        try
        {
            ResultSet NewSection = stmt.executeQuery("SELECT COUNT(id) AS sectcount FROM bereich WHERE bezeichnung = '" +section +"'");
            NewSection.next();
            
            
            if(NewSection.getInt("sectcount") == 0)
            {      
                ResultSet getID = stmt.executeQuery("SELECT id FROM bereich ORDER BY ID DESC LIMIT 1");                 
                getID.next();
                int newID = getID.getInt(1) +1;
                stmt.executeUpdate("INSERT INTO bereich (id,bezeichnung) VALUES ("+newID +",'"+section+"')");
                return true;
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
            exe.printStackTrace();
        }   
        
        disconnect();
        return false;
    
    }
    
    /**
     * 
     * Löscht einen Bereich aus der Datenbank
     * 
     * @param SectionID      ID des Bereichs, welcher gelöscht werden soll
     * @return               true, wenn der Bereich aus der Datenbank gelöscht wurde | false wenn nicht
     */
    
    public boolean deleteSection(int SectionID)
    {
        connect();
        
        try
        {
            stmt.executeUpdate("DELETE FROM bereich WHERE id = '"+SectionID+"'"); 
            return true;
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        return false;
   
    }
    
    /**
     * 
     * Gibt die ID eines Bereichs aus der Datenbank aus
     * 
     * @param section   Name des Bereichs, dessen ID ausgegeben werden soll
     * @return          ID des Bereichs          
     */
    
    public int getSectionID(String section)
    {
        int SectionID = 0;
        
        connect();
        
        try
        {
           SectionID = stmt.executeQuery("SELECT id FROM bereich WHERE bezeichnung = '"+section+"'").getInt(1);
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }      
        
        disconnect();
        
        return SectionID;
    
    }
    
    
    /**************************************************************************************************************/
    
    /**
     * 
     * Sucht nach einem Suchbegriff in der Datenbank
     * 
     * @param keyword   Suchbegriff nach dem gesucht werden soll
     * @param type      Typ nach dem gesucht werden soll (asset oder task)
     * @return          Suchergebnis
     */
    
    public ArrayList<String[]> Search(String keyword, String type)
    {

        ArrayList<String[]> searchresult = new ArrayList<>();
        String[] temp;
        int Arraypos;
        
        connect();
        
        try
        {
            switch (type) {
                
                case "asset":

                    ResultSet assetvar = stmt.executeQuery("SELECT * FROM assets where titel LIKE '%"+keyword+"%'");
                    while(assetvar.next())
                    {
                        temp = new String[6];
                        Arraypos = 0;
                        
                        for(int i=0;i<6;i++)
                        {
                            temp[Arraypos] = assetvar.getString(i+1);
                            Arraypos++;
                        }
                        
                        searchresult.add(temp);
                    }   break;
                    
                case "task":
                    
                    ResultSet taskvar = stmt.executeQuery("SELECT * FROM auftraege where titel LIKE '%"+keyword+"%'");
                    while(taskvar.next())
                    {
                        temp = new String[10];
                        Arraypos = 0;
                        
                        for(int i=0;i<10;i++)
                        {
                            temp[Arraypos] = taskvar.getString(i+1);
                            Arraypos++;
                        }
                        
                        searchresult.add(temp);
                    }   break;
                    
            }
            
        }
        catch(SQLException exe)
        {
            ErrorWindow(exe);
        }
        
        disconnect();
        return searchresult;
    
    }
        
    /**************************************************************************************************************/
    
    
    public static void main(String args[]) throws NoSuchAlgorithmException
    {
       DBConnect a = new DBConnect();
       
       
       /*
       *    Bugs:
       *
       *    "Integer number too large" wenn PLZ mit 0 beginnt ?
       */
       
       //a.addUser("tollespw123", "Thomas", "Müller", "tm@spam.de", "AB", "AB");
       //a.addUser("dorte123", "Gustav", "Gans", "GGans@spam.de", "2D", "4");
       //a.addUser("fritz321", "Karsten", "Schmidt", "KSchmidt@spam.de", "3D", "3");
       //a.addUser("auto123", "Thorsten", "Kohlmann", "TKohlmann@spam.de", "2D", "4");
       //a.addUser("eimer", "Franzi", "Meier", "FMaier@spam.de", "3D", "3");
       //a.addUser("wal", "Henry", "Ford", "HenryF@spam.de", "MA", "2");
       //System.out.println(a.getUserData(a.getUserID("PMAccount@spam.de"))[5].toString());
       //System.out.println(a.CachedUserData.get(7));
       //System.out.println(a.authenticate("PMAccount@spam.de","pm123"));
       //System.out.println(a.getUserData("Hanswurst@blub.de")[6]);
       //a.deleteUser("bla1@blub.de"); 
       //a.addTask("test2", "ASUS", "Postweg", 12, 02635, "Mittweida", "21.03.2013", "A", "start");
       //a.updateTask(1, "b", "b", "b", 01, 04524, "b", "b", "b", "b");
       //a.updateTask(2, "A", "A", "A", 0, 0, "A", "A", "A", "A");
       //a.updateUser("bla", "bla", "bla", "Tom@ges3231chirrspueler.tw", "bla", "bla");
       //a.deleteTask(2);
       //System.out.println("TaskID: " +a.getTaskID("test2"));
       //System.out.println(a.addAsset("Stuhl", "C:\\StuhlA", 1, 1, 2));
       //a.updateAsset(1, "bla", "bli", "blubb", 12, 3);
       //a.deleteAsset(2);
       //a.addAssetType("Bla");
       //a.updateAssetType(1, "FISCH");
       //a.addCompany("ARAL", "Feldweg 7", 7, 98, null, null, null);
       //a.addAssetCategory("Schraenke");
       //a.updateAssetCategory(1, "tisch");
       //a.deleteAssetCategory(1);
       //System.out.println(a.getAssetCategoryID("Schraenke"));
       
       /*
       for(Object[] p : a.getColleagues(a.getUserID("PMAccrount@spam.de")))
       
       {
          System.out.println(p[0].toString());
          System.out.println(p[1].toString());
          System.out.println(p[2].toString());
          System.out.println(p[3].toString());
          System.out.println(p[4].toString()); 
          System.out.println(p[5].toString()); 
          
       }
               
               */
       
       /*
        for(Object[] p : a.getTasks())
       
       {
          System.out.println(p[0].toString());
          System.out.println(p[1].toString());
          System.out.println(p[2].toString());
          System.out.println(p[3].toString());
          System.out.println(p[4].toString()); 
          System.out.println(p[5].toString()); 
          System.out.println(p[6].toString()); 
          System.out.println(p[7].toString()); 
          System.out.println(p[8].toString()); 
          System.out.println(p[9].toString()); 
 
       }
               */
               
       
        
       
       //---------------------------------------- Test Benutzer (22.11 11:35 - ok)
       
       //a.addUser("tollespw123", "Thomas", "Müller", "tm@spam.de", "AB", "AB");
       //a.addUser("tollespw123", "Thomas", "Müller", "tm@spam.de", "AB", "AB");
       //a.updateUser("ultrapw123", "Hans", "Wurst", "tm@spam.de", "CA","CV");

       
       //---------------------------------------- Test Aufgaben (22.11 11:27 - ok)
       
       //a.addTask("Wohnung digitalisieren", "ARAL", "Feldstraße", 3, 53548, "Dresden", "24.12.2014", "Robert Keller", "offen");
       //a.updateTask(1, "Wohnung ausstatten", "DBAG", "Bahnhofstraße", 1, 30147, "Irgendwo", "13.04.2015", "Thomas Müller", "in Bearbeitung");
       //System.out.println(a.getTaskID("Wohnung ausstatten"));
       //a.deleteTask(1);
       
       
       //---------------------------------------- Test Unternehmen (22.11 11:21 - ok)
       
       //a.addCompany("DB AG", "Bahnhofstraße", 4, 96448, "Herr Reuter", "01623452887", "Reuter@dbag.de");                      // Bug bei PLZ mit "0XXXX"
       //a.updateCompany(1, "ARAL", "Tankstraße", 19, 27423, "Frau Tunichtgut", "01746348972", "tunichtgut@aral.com");
       //System.out.println(a.getCompanyID("ARAL"));  //a.deleteCompany(1);
       
       
       //---------------------------------------- Test Asset (22.11 11:16 - ok)
       
       //System.out.println(a.addAsset("Sofa_gr", "C:\\Assets\\Sofas\\Sofa_gruen.bla", 1, 1, 2));
       //a.updateAsset(1, "Sofa_blau", "C:\\Assets\\Sofas\\Sofa_blau.bla", "Sofas",2, 1);
       //System.out.println(a.getAssetID("Sofa_blau"));
       //a.deleteAsset(1);
       
       
       //---------------------------------------- Test Asset Typ (22.11 11:13 - ok)
       
       //a.addAssetType("Tisch");
       //a.updateAssetType(1, "Sideboard");
       //System.out.println(a.getAssetTypeID("Sideboard"));
       //a.deleteAssetType(1);       
       
       //---------------------------------------- Test Asset Kategorie (22.11 11:11 - ok)
       
       //a.addAssetCategory("Tische");
       //a.updateAssetCategory(1, "Spiegel");
       //System.out.println(a.getAssetCategoryID("Spiegel"));
       //a.deleteAssetCategory(1);
       
       //---------------------------------------- Test Beziehung (22.11 11:08 - ok)
       
       //a.addRelationship(1, 1);
       //a.updateRelationship(1, 2, 2);
       //System.out.println(a.getRelationshipID(2, 2));
       //a.deleteRelationship(1);
       
       //---------------------------------------- Test Berechtigung (22.11 11:05 - ok)
       
       //a.addPermission("Admin");
       //a.updatePermission(1, "User");
       //System.out.println(a.getPermissionID("User"));
       //a.deletePermission(1);       
       
       //---------------------------------------- Test Bereich (22.11 11:00 - ok)
       
       //a.addSection("test");
       //a.updateSection(1, "test2");
       //System.out.println(a.getSectionID("test2"));
       //a.deleteSection(1);
       
       
       /*
       for(String[] s : a.getTasks())
       {
           System.out.println(s[2]);
       }  
               */

       
       
       
       
       
       
       
        
    
    }
   
}
